{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import datetime, os\n",
    "#hide tf logs \n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'  # or any {'0', '1', '2'} \n",
    "#0 (default) shows all, 1 to filter out INFO logs, 2 to additionally filter out WARNING logs, and 3 to additionally filter out ERROR logs\n",
    "import scipy.optimize\n",
    "import scipy.io\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "import time\n",
    "from pyDOE import lhs         #Latin Hypercube Sampling\n",
    "import seaborn as sns \n",
    "import codecs, json\n",
    "\n",
    "# generates same random numbers each time\n",
    "np.random.seed(1234)\n",
    "tf.random.set_seed(1234)\n",
    "\n",
    "print(\"TensorFlow version: {}\".format(tf.__version__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "88G3Lt8xn-Oo"
   },
   "source": [
    "# *Data Prep*\n",
    "\n",
    "Training and Testing data is prepared from the solution file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = scipy.io.loadmat('Data/burgers_shock_mu_01_pi.mat')  \t# Load data from file\n",
    "x = data['x']                                   # 256 points between -1 and 1 [256x1]\n",
    "t = data['t']                                   # 100 time points between 0 and 1 [100x1] \n",
    "usol = data['usol']                             # solution of 256x100 grid points\n",
    "\n",
    "X, T = np.meshgrid(x,t)                         # makes 2 arrays X and T such that u(X[i],T[j])=usol[i][j] are a tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ZyGxyaOAcqpi"
   },
   "source": [
    "# *Test Data*\n",
    "\n",
    "We prepare the test data to compare against the solution produced by the PINN."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "yddknKA2Xohp"
   },
   "outputs": [],
   "source": [
    "''' X_u_test = [X[i],T[i]] [25600,2] for interpolation'''\n",
    "X_u_test = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
    "\n",
    "# Domain bounds\n",
    "lb = X_u_test[0]  # [-1. 0.]\n",
    "ub = X_u_test[-1] # [1.  0.99]\n",
    "\n",
    "'''\n",
    "   Fortran Style ('F') flatten,stacked column wise!\n",
    "   u = [c1 \n",
    "        c2\n",
    "        .\n",
    "        .\n",
    "        cn]\n",
    "\n",
    "   u =  [25600x1] \n",
    "'''\n",
    "u = usol.flatten('F')[:,None] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aJ5oBRtEXnyu"
   },
   "source": [
    "# *Training Data*\n",
    "\n",
    "The boundary conditions serve as the test data for the PINN and the collocation points are generated using **Latin Hypercube Sampling**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8UVJmvZbXjXb"
   },
   "outputs": [],
   "source": [
    "def trainingdata(N_u,N_f):\n",
    "\n",
    "    '''Boundary Conditions'''\n",
    "\n",
    "    #Initial Condition -1 =< x =<1 and t = 0  \n",
    "    leftedge_x = np.hstack((X[0,:][:,None], T[0,:][:,None])) #L1\n",
    "    leftedge_u = usol[:,0][:,None]\n",
    "\n",
    "    #Boundary Condition x = -1 and 0 =< t =<1\n",
    "    bottomedge_x = np.hstack((X[:,0][:,None], T[:,0][:,None])) #L2\n",
    "    bottomedge_u = usol[-1,:][:,None]\n",
    "\n",
    "    #Boundary Condition x = 1 and 0 =< t =<1\n",
    "    topedge_x = np.hstack((X[:,-1][:,None], T[:,0][:,None])) #L3\n",
    "    topedge_u = usol[0,:][:,None]\n",
    "\n",
    "    all_X_u_train = np.vstack([leftedge_x, bottomedge_x, topedge_x]) # X_u_train [456,2] (456 = 256(L1)+100(L2)+100(L3))\n",
    "    all_u_train = np.vstack([leftedge_u, bottomedge_u, topedge_u])   #corresponding u [456x1]\n",
    "\n",
    "    #choose random N_u points for training\n",
    "    idx = np.random.choice(all_X_u_train.shape[0], N_u, replace=False) \n",
    "\n",
    "    X_u_train = all_X_u_train[idx, :] #choose indices from  set 'idx' (x,t)\n",
    "    u_train = all_u_train[idx,:]      #choose corresponding u\n",
    "\n",
    "    '''Collocation Points'''\n",
    "\n",
    "    # Latin Hypercube sampling for collocation points \n",
    "    # N_f sets of tuples(x,t)\n",
    "    X_f_train = lb + (ub-lb)*lhs(2,N_f) \n",
    "    X_f_train = np.vstack((X_f_train, X_u_train)) # append training points to collocation points \n",
    "\n",
    "    return X_f_train, X_u_train, u_train \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dp4nc2S7bwzz"
   },
   "source": [
    "# **PINN**\n",
    "\n",
    "Generate a **PINN** of L hidden layers, each with n neurons. \n",
    "\n",
    "Initialization: ***Xavier***\n",
    "\n",
    "Activation: *tanh (x)*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Sequentialmodel(tf.Module): \n",
    "    def __init__(self, layers, name=None):\n",
    "       \n",
    "        self.W = []  #Weights and biases\n",
    "        self.parameters = 0 #total number of parameters\n",
    "        \n",
    "        for i in range(len(layers)-1):\n",
    "            \n",
    "            input_dim = layers[i]\n",
    "            output_dim = layers[i+1]\n",
    "            \n",
    "            #Xavier standard deviation \n",
    "            std_dv = np.sqrt((2.0/(input_dim + output_dim)))\n",
    "\n",
    "            #weights = normal distribution * Xavier standard deviation + 0\n",
    "            w = tf.random.normal([input_dim, output_dim], dtype = 'float64') * std_dv\n",
    "                       \n",
    "            w = tf.Variable(w, trainable=True, name = 'w' + str(i+1))\n",
    "\n",
    "            b = tf.Variable(tf.cast(tf.zeros([output_dim]), dtype = 'float64'), trainable = True, name = 'b' + str(i+1))\n",
    "                    \n",
    "            self.W.append(w)\n",
    "            self.W.append(b)\n",
    "            \n",
    "            self.parameters +=  input_dim * output_dim + output_dim\n",
    "    \n",
    "    def evaluate(self,x):\n",
    "        \n",
    "        x = (x-lb)/(ub-lb)\n",
    "        \n",
    "        a = x\n",
    "        \n",
    "        for i in range(len(layers)-2):\n",
    "            \n",
    "            z = tf.add(tf.matmul(a, self.W[2*i]), self.W[2*i+1])\n",
    "            a = tf.nn.tanh(z)\n",
    "            \n",
    "        a = tf.add(tf.matmul(a, self.W[-2]), self.W[-1]) # For regression, no activation to last layer\n",
    "        return a\n",
    "    \n",
    "    def get_weights(self):\n",
    "\n",
    "        parameters_1d = []  # [.... W_i,b_i.....  ] 1d array\n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "            \n",
    "            w_1d = tf.reshape(self.W[2*i],[-1])   #flatten weights \n",
    "            b_1d = tf.reshape(self.W[2*i+1],[-1]) #flatten biases\n",
    "            \n",
    "            parameters_1d = tf.concat([parameters_1d, w_1d], 0) #concat weights \n",
    "            parameters_1d = tf.concat([parameters_1d, b_1d], 0) #concat biases\n",
    "        \n",
    "        return parameters_1d\n",
    "        \n",
    "    def set_weights(self,parameters):\n",
    "                \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            shape_w = tf.shape(self.W[2*i]).numpy() # shape of the weight tensor\n",
    "            size_w = tf.size(self.W[2*i]).numpy() #size of the weight tensor \n",
    "            \n",
    "            shape_b = tf.shape(self.W[2*i+1]).numpy() # shape of the bias tensor\n",
    "            size_b = tf.size(self.W[2*i+1]).numpy() #size of the bias tensor \n",
    "                        \n",
    "            pick_w = parameters[0:size_w] #pick the weights \n",
    "            self.W[2*i].assign(tf.reshape(pick_w,shape_w)) # assign  \n",
    "            parameters = np.delete(parameters,np.arange(size_w),0) #delete \n",
    "            \n",
    "            pick_b = parameters[0:size_b] #pick the biases \n",
    "            self.W[2*i+1].assign(tf.reshape(pick_b,shape_b)) # assign \n",
    "            parameters = np.delete(parameters,np.arange(size_b),0) #delete \n",
    "\n",
    "            \n",
    "    def loss_BC(self,x,y):\n",
    "\n",
    "        loss_u = tf.reduce_mean(tf.square(y-self.evaluate(x)))\n",
    "        return loss_u\n",
    "\n",
    "    def loss_PDE(self, x_to_train_f):\n",
    "    \n",
    "        g = tf.Variable(x_to_train_f, dtype = 'float64', trainable = False)\n",
    "    \n",
    "        nu = 0.01/np.pi\n",
    "\n",
    "        x_f = g[:,0:1]\n",
    "        t_f = g[:,1:2]\n",
    "\n",
    "        with tf.GradientTape(persistent=True) as tape:\n",
    "\n",
    "            tape.watch(x_f)\n",
    "            tape.watch(t_f)\n",
    "\n",
    "            g = tf.stack([x_f[:,0], t_f[:,0]], axis=1)   \n",
    "\n",
    "            z = self.evaluate(g)\n",
    "            u_x = tape.gradient(z,x_f)\n",
    "\n",
    "        u_t = tape.gradient(z,t_f)    \n",
    "        u_xx = tape.gradient(u_x, x_f)\n",
    "\n",
    "        del tape\n",
    "\n",
    "        f = u_t + (self.evaluate(g))*(u_x) - (nu)*u_xx\n",
    "\n",
    "        loss_f = tf.reduce_mean(tf.square(f))\n",
    "\n",
    "        return loss_f\n",
    "    \n",
    "    def loss(self,x,y,g):\n",
    "\n",
    "        loss_u = self.loss_BC(x,y)\n",
    "        loss_f = self.loss_PDE(g)\n",
    "\n",
    "        loss = loss_u + loss_f\n",
    "\n",
    "        return loss, loss_u, loss_f\n",
    "    \n",
    "    def optimizerfunc(self,parameters):\n",
    "        \n",
    "        self.set_weights(parameters)\n",
    "       \n",
    "        with tf.GradientTape() as tape:\n",
    "            tape.watch(self.trainable_variables)\n",
    "            \n",
    "            loss_val, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "            \n",
    "        grads = tape.gradient(loss_val,self.trainable_variables)\n",
    "                \n",
    "        del tape\n",
    "        \n",
    "        grads_1d = [ ] #flatten grads \n",
    "        \n",
    "        for i in range (len(layers)-1):\n",
    "\n",
    "            grads_w_1d = tf.reshape(grads[2*i],[-1]) #flatten weights \n",
    "            grads_b_1d = tf.reshape(grads[2*i+1],[-1]) #flatten biases\n",
    "\n",
    "            grads_1d = tf.concat([grads_1d, grads_w_1d], 0) #concat grad_weights \n",
    "            grads_1d = tf.concat([grads_1d, grads_b_1d], 0) #concat grad_biases\n",
    "\n",
    "        return loss_val.numpy(), grads_1d.numpy()\n",
    "    \n",
    "    def optimizer_callback(self,parameters):\n",
    "               \n",
    "        loss_value, loss_u, loss_f = self.loss(X_u_train, u_train, X_f_train)\n",
    "        \n",
    "        u_pred = self.evaluate(X_u_test)\n",
    "        error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)\n",
    "        \n",
    "        tf.print(loss_value, loss_u, loss_f, error_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bOjuHdzAhib-"
   },
   "source": [
    "# *Solution Plot*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UWqNuRMLhg4m"
   },
   "outputs": [],
   "source": [
    "def solutionplot(u_pred,X_u_train,u_train):\n",
    "    \n",
    "    fig, ax = plt.subplots()\n",
    "    ax.axis('off')\n",
    "\n",
    "    gs0 = gridspec.GridSpec(1, 2)\n",
    "    gs0.update(top=1-0.06, bottom=1-1/3, left=0.15, right=0.85, wspace=0)\n",
    "    ax = plt.subplot(gs0[:, :])\n",
    "\n",
    "    h = ax.imshow(u_pred, interpolation='nearest', cmap='rainbow', \n",
    "                extent=[T.min(), T.max(), X.min(), X.max()], \n",
    "                origin='lower', aspect='auto')\n",
    "    divider = make_axes_locatable(ax)\n",
    "    cax = divider.append_axes(\"right\", size=\"5%\", pad=0.05)\n",
    "    fig.colorbar(h, cax=cax)\n",
    "    \n",
    "    ax.plot(X_u_train[:,1], X_u_train[:,0], 'kx', label = 'Data (%d points)' % (u_train.shape[0]), markersize = 4, clip_on = False)\n",
    "\n",
    "    line = np.linspace(x.min(), x.max(), 2)[:,None]\n",
    "    ax.plot(t[25]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "    ax.plot(t[50]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
    "    ax.plot(t[75]*np.ones((2,1)), line, 'w-', linewidth = 1)    \n",
    "\n",
    "    ax.set_xlabel('$t$')\n",
    "    ax.set_ylabel('$x$')\n",
    "    ax.legend(frameon=False, loc = 'best')\n",
    "    ax.set_title('$u(x,t)$', fontsize = 10)\n",
    "    \n",
    "    ''' \n",
    "    Slices of the solution at points t = 0.25, t = 0.50 and t = 0.75\n",
    "    '''\n",
    "    \n",
    "    ####### Row 1: u(t,x) slices ##################\n",
    "    gs1 = gridspec.GridSpec(1, 3)\n",
    "    gs1.update(top=1-1/3, bottom=0, left=0.1, right=0.9, wspace=0.5)\n",
    "\n",
    "    ax = plt.subplot(gs1[0, 0])\n",
    "    ax.plot(x,usol.T[25,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "    ax.plot(x,u_pred.T[25,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "    ax.set_xlabel('$x$')\n",
    "    ax.set_ylabel('$u(x,t)$')    \n",
    "    ax.set_title('$t = 0.25s$', fontsize = 10)\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([-1.1,1.1])\n",
    "    ax.set_ylim([-1.1,1.1])\n",
    "\n",
    "    ax = plt.subplot(gs1[0, 1])\n",
    "    ax.plot(x,usol.T[50,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "    ax.plot(x,u_pred.T[50,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "    ax.set_xlabel('$x$')\n",
    "    ax.set_ylabel('$u(x,t)$')\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([-1.1,1.1])\n",
    "    ax.set_ylim([-1.1,1.1])\n",
    "    ax.set_title('$t = 0.50s$', fontsize = 10)\n",
    "    ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.35), ncol=5, frameon=False)\n",
    "\n",
    "    ax = plt.subplot(gs1[0, 2])\n",
    "    ax.plot(x,usol.T[75,:], 'b-', linewidth = 2, label = 'Exact')       \n",
    "    ax.plot(x,u_pred.T[75,:], 'r--', linewidth = 2, label = 'Prediction')\n",
    "    ax.set_xlabel('$x$')\n",
    "    ax.set_ylabel('$u(x,t)$')\n",
    "    ax.axis('square')\n",
    "    ax.set_xlim([-1.1,1.1])\n",
    "    ax.set_ylim([-1.1,1.1])    \n",
    "    ax.set_title('$t = 0.75s$', fontsize = 10)\n",
    "    \n",
    "    plt.savefig('Burgers.png',dpi = 500)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "YRuuEXx-eeWa"
   },
   "source": [
    "# *Model Training and Testing*\n",
    "\n",
    "A function '**model**' is defined to generate a NN as per the input set of hyperparameters, which is then trained and tested. The L2 Norm of the solution error is returned as a comparison metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_u = 100 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "layers = np.array([2,20,20,20,20,20,20,20,20,1]) #8 hidden layers\n",
    "\n",
    "PINN = Sequentialmodel(layers)\n",
    "\n",
    "init_params = PINN.get_weights().numpy()\n",
    "\n",
    "start_time = time.time() \n",
    "\n",
    "# train the model with Scipy L-BFGS optimizer\n",
    "results = scipy.optimize.minimize(fun = PINN.optimizerfunc, \n",
    "                                  x0 = init_params, \n",
    "                                  args=(), \n",
    "                                  method='L-BFGS-B', \n",
    "                                  jac= True,        # If jac is True, fun is assumed to return the gradient along with the objective function\n",
    "                                  callback = PINN.optimizer_callback, \n",
    "                                  options = {'disp': None,\n",
    "                                            'maxcor': 200, \n",
    "                                            'ftol': 1 * np.finfo(float).eps,  #The iteration stops when (f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= ftol\n",
    "                                            'gtol': 5e-8, \n",
    "                                            'maxfun':  50000, \n",
    "                                            'maxiter': 5000,\n",
    "                                            'iprint': -1,   #print update every 50 iterations\n",
    "                                            'maxls': 50})\n",
    "\n",
    "elapsed = time.time() - start_time                \n",
    "print('Training time: %.2f' % (elapsed))\n",
    "\n",
    "print(results)\n",
    "\n",
    "PINN.set_weights(results.x)\n",
    "\n",
    "''' Model Accuracy ''' \n",
    "u_pred = PINN.evaluate(X_u_test)\n",
    "\n",
    "error_vec = np.linalg.norm((u-u_pred),2)/np.linalg.norm(u,2)        # Relative L2 Norm of the error (Vector)\n",
    "print('Test Error: %.5f'  % (error_vec))\n",
    "\n",
    "u_pred = np.reshape(u_pred,(256,100),order='F')                        # Fortran Style ,stacked column wise!\n",
    "\n",
    "''' Solution Plot '''\n",
    "solutionplot(u_pred,X_u_train,u_train)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plot of collocation points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "N_u = 100 #Total number of data points for 'u'\n",
    "N_f = 10000 #Total number of collocation points \n",
    "\n",
    "# Training data\n",
    "X_f_train, X_u_train, u_train = trainingdata(N_u,N_f)\n",
    "\n",
    "fig,ax = plt.subplots()\n",
    "\n",
    "plt.plot(X_u_train[:,1], X_u_train[:,0], '*', color = 'red', markersize = 5, label = 'Boundary collocation = 100')\n",
    "plt.plot(X_f_train[:,1], X_f_train[:,0], 'o', markersize = 0.5, label = 'PDE collocation = 10,000')\n",
    "\n",
    "plt.xlabel('t')\n",
    "plt.ylabel('x')\n",
    "plt.title('Collocation points')\n",
    "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "fig.savefig('collocation_points_Burgers.png', dpi = 500, bbox_inches='tight')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
